// 设置缓存
export const LOCAL = {
  prev: 'xndxznkf_',
  /**
  * 存储localStorage
  */
  set (name, data) {
    if (!name) return;
    name = this.prev + name;
    if (typeof data !== 'string') {
      data = JSON.stringify(data);
    }
    window.localStorage.setItem(name, data);
  },
  /**
  * 获取localStorage
  */
  get (name) {
    if (!name) return;
    name = this.prev + name;
    var value = window.localStorage.getItem(name);
    if (value !== null) {
      try {
        value = JSON.parse(value);
      } catch (e) {
        value = value;
      }
    }
    return value;
  },
  /**
  * 删除localStorage
  * name 为空时  清除所有数据
  */
  remove (name) {
    if (!name) {
      window.localStorage.clear();
    }else {
      name = this.prev + name;
      window.localStorage.removeItem(name);
    }
  },
}

/**
 *cookie
 */
export const cookie = {
  /*
  作用：通过传key值，返回需要的当前key的value值，即封装cookie的查
  参数：name->cookie中的key值
  返回：有则返回value，无则返回""空
  调用方法 console.log(getCookie("phone"));
  */
  get (name) {
    name += '_' + location.port;
    var cookieTxt = document.cookie;
    var arr = cookieTxt.split("; ");
    for(var i=0; i<arr.length; i++) {
      var arr1 = arr[i].split("=");
      if(decodeURIComponent(arr1[0]) == name) {
        return decodeURIComponent(arr1[1]);
      }
    }
    return "";
  },
  /*
  作用：封装cookie的增和改
  参数：name->当前这条cookie的名称，value->当前cookie的值，day->当前cookie存在的天数为0或为空则为有效时间是当前会话，path->为当前cookie的有效路径不设则为根路径/
  */
  set (name,value,day,path) {
    name += '_' + location.port;
    var result = "";
    result += encodeURIComponent(name)+"="+encodeURIComponent(value);
    if(day) {
      var date = new Date();
      date.setDate(date.getDate()+day);
      result += "; expires="+date;
    }
    if(path) {
      result += "; path="+path;
    } else {
      result += "; path=/";
    }
    document.cookie = result;
  },
  /*
  作用：封装cookie的删
  参数：name->需要删除的cookie的名称
  */
  remove (name) {
    name += '_' + location.port;
    this.set(name,"",-1);
  }
}

export const storage = {
  /**
  * 存储sessionStorage
  */
  set (name, data) {
    if (!name) return;
    name += '_' + location.port;
    if (typeof data !== 'string') {
      data = JSON.stringify(data);
    }
    window.sessionStorage.setItem(name, data);
  },
  /**
  * 获取sessionStorage
  */
  get (name) {
    if (!name) return;
    name += '_' + location.port;
    var value = window.sessionStorage.getItem(name);
    if (value !== null) {
      try {
        value = JSON.parse(value);
      } catch (e) {
        value = value;
      }
    }
    return value;
  },
  /**
  * 删除sessionStorage
  * name 为空时  清除所有数据
  */
  remove (name) {
    if (!name) {
      window.sessionStorage.clear();
    }else {
      name += '_' + location.port;
      window.sessionStorage.removeItem(name);
    }
  },
}

/**
  *格式化时间
  *@param {String} time [可以new Date()的时间]
  *@param {String} format [时间格式化类型
      yyyy            年
      M               月       不用补0
      MM              月       需要补0
      W               周       不用补0
      WW              周       需要补0
      d               日       不用补0
      dd              日       需要补0
      H               24小时    不用补0
      HH              24小时    需要补0
      h               12小时    不用补0
      hh              12小时    需要补0
      m               分       不用补0
      mm              分       需要补0
      s               秒       不用补0
      ss              秒       需要补0
      timestamp       时间戳   
      例子：yyyy年MM月dd日 HH:mm:ss
    ]
 */
export function switchTime (time, format) {
  format = format ? format : 'yyyy年MM月dd日 HH:mm:ss';
  var res = format;
  var date = new Date(time);
  var timestamp = date.getTime(),
    year = date.getFullYear(),
    month = date.getMonth() + 1,
    day = date.getDate(),
    hours = date.getHours(),
    minutes = date.getMinutes(),
    seconds = date.getSeconds(),
    week = date.getDay(); // 0是星期日
  // 判断传入是否可以转换为时间
  if (!year) {
    return time;
  }
  // 替换时间戳
  res = res.replace(/timestamp/g, timestamp);
  // 替换年
  res = res.replace(/yyyy/g, year);
  // 替换月
  res = res.replace(/MM/g, makeUpNum(month));
  res = res.replace(/M/g, month);
  // 替换日
  res = res.replace(/dd/g, makeUpNum(day));
  res = res.replace(/d/g, day);
  // 替换时
  res = res.replace(/HH/g, makeUpNum(hours));
  res = res.replace(/H/g, hours);
  // 替换分
  res = res.replace(/mm/g, makeUpNum(minutes));
  res = res.replace(/m/g, minutes);
  // 替换秒
  res = res.replace(/ss/g, makeUpNum(seconds));
  res = res.replace(/s/g, seconds);
  // 替换周
  res = res.replace(/WW/g, makeUpNum(week));
  res = res.replace(/W/g, week);
  return res;
}

/**
 *数字补0
 @param {Number} val [需要补0的数]
 */
export function makeUpNum (val) {
    return val < 10 ? '0' + parseInt(val) : val;
}

/**
 * 获取小数点位数 
*/
export function getDecimalPlaces(num) {
  // 先转成字符串，防止传入的是数字
  const str = String(num);
  // 匹配小数点后的数字
  const match = str.match(/\.(\d+)$/);
  // 如果有小数部分，返回长度；否则返回 0
  return match ? match[1].length : 0;
}

/**
 * 计算历史时间距离当前有多久
 * */
export function calcTimeToNowText(time) {
  let res = '';
  let now = new Date();
  let his = new Date(time);

  let hours = (now - his) / (60*60*1000);
  if(hours < 1) {
    let fz = Math.floor(60*hours);
    if(fz < 1) {
      res = '1分钟内';
    } else {
      res = fz+'分钟前';
    }
  } else if(hours < 24) {
    res = Math.floor(hours)+'小时前';
  } else {
    let today = new Date(now.getFullYear(), now.getMonth(), now.getDate()-1, 0, 0, 0);
    if(his > today) {
      res = '昨天';
    } else {
      res = his.getFullYear()+'-'+(makeUpNum(his.getMonth()+1))+'-'+makeUpNum(his.getDate());
    }
  }
  return res;
}

/**
 *拷贝
 */
export function copy (data) {
    return JSON.parse(JSON.stringify(data));
}

/**
 *判断是否为空
 *@return {Boolean} [true为空，false不为空]
 */
export function isEmpty (val) {
  if (typeof val == 'string') {
    val = val.trim();
  }
  return !val && val!==0 && typeof val!=="boolean"?true:false;
}

// 保留小数位数
/**
 *保留几位小数
 *@param {Number} val [传入的值]
 *@param {Number} num [保留小数的位数]
 *@return {Number} [保留小数位数后的数字]
 */
export function toFixed(val, num) {
  var res = Number(val);
  if (!res) {
    return res;
  }
  res = res.toFixed(num);
  var arr = ('' + res).split('.');
  if (arr[1].length > num) {
    arr[1] = arr[1].slice(0, num);
    res = arr.join('.');
  }
  return res;
}

/**
 *根据编码获取对应名称
 *list 列表
 *value 值
 *labelKey
 *valueKey
 *else 不存在时，显示内容，默认''
 */
export function getLabelByValue (list, value, labelKey='label', valueKey='value', empty='') {
  var res = empty || '';
  if (!list || isEmpty(value)) {
    return res;
  }

  for (var i = 0; i < list.length; i++) {
    if (list[i][valueKey] == value) {
      res = list[i][labelKey];
      break;
    }
  }
  return res;
}

// 根据最后一集code获取族列表
export function getClanByValue(list, value, valueKey='value', childrenKey='children') {
  let res = [];
  ergodic(list, []);
  return res;

  function ergodic(arr, aMenu) {
    for(let i = 0; i < arr.length; i++) {
      if(res.length) {
        break;
      }
      let item = arr[i];
      let brr = [...aMenu, item];
      if(item[valueKey] == value) {
        res = brr;
        break;
      }
      if(item[childrenKey]) {
        ergodic(item[childrenKey], brr);
      }
    }
  }
}

/*使用方法
<el-input v-model="form.num" @blur="form.num = $number(form.num,2)"></el-input>
*/
/**
 *转换为数字小数位数
 *@param {Number} data 需要保留小数点的数，如果不是数，返回'' 
 *@param {Number} precision 小数点位数
 *@return {Number} 返回截取小数点后的数，如果不是数，返回''
 */
export function toNumber (data, precision) {
  let value = data;
  // 判断是否是数字
  if (!/^(\-|\+)?\d+(\.\d+)?$/.test(value)) {
    return '';
  }
  var content = parseFloat(value);
  if (!content) {
    content = 0.00;
  }
  let arg_precision = precision || 0;//默认保留至整数
  return Number(content.toFixed(arg_precision));
}

/**
 *根据身份证获取出生日期
 */
export function getBirthdayByIdcard (idcard) {
  var res = '';
  if (idcard) {
    idcard = '' + idcard;
  } else {
    return '';
  }
  if (idcard.length == 15) {
    res = '19' + idcard.slice(6,8) + '-' + idcard.slice(8,10) + '-' + idcard.slice(10,12);
  } else if (idcard.length == 18) {
    res = idcard.slice(6,10) + '-' + idcard.slice(10,12) + '-' + idcard.slice(12,14);
  }
  return res;
}

/**
 *根据身份证获取性别
 * 1男2女
 */
export function getSexByIdcard (idcard) {
  var res = '';
  if (idcard) {
    idcard = '' + idcard;
  } else {
    return '';
  }
  if (idcard.length == 15) {
    res = parseInt(idcard[14]) % 2 == 1 ? 1 : 2;
  } else if (idcard.length == 18) {
    res = parseInt(idcard[16]) % 2 == 1 ? 1 : 2;
  }
  return res;
}

/*使用方法
obj = { aa: [ {name: '张三'} ] }
getValueByKeys(obj, 'aa', 0, 'name');
getValue () {
  return getValueByKeys(this.detail, ...arguments);
}
*/
/**
 *根据key获取对象的相应值，后面的都是参数，第二个是第一级，第三个是第二级参数
 */
export function getValueByKeys () {
    var args = arguments;
    var res = args[0]; // 第一个是对象
    if (!res) {
        return '';
    }
    for (var i = 1; i < args.length; i++) {
        var item = args[i];
        if (isEmpty(res[item])) {
            res = '';
            break;
        } else {
            res = res[item];
        }
    }
    return res;
}

/**
 * 等待时间
 * @param {String} time [等待的时间]
 **/
export const waitTimeout = function (time) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve();
    }, time);
  })
}

/**
 * 获取唯一ID
 * @param {Number} length [随机数长度]
 * */
export function getId(length = 5) {
  return Number(Math.random().toString().substr(3, length)) + Date.now();
}

/**
 * 数字金额转换为大写人民币汉字
 * */
export const convertCurrency = (money) => {
  //汉字的数字
  var cnNums = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖');
  //基本单位
  var cnIntRadice = new Array('', '拾', '佰', '仟');
  //对应整数部分扩展单位
  var cnIntUnits = new Array('', '万', '亿', '兆');
  //对应小数部分单位
  var cnDecUnits = new Array('角', '分', '毫', '厘');
  //整数金额时后面跟的字符
  var cnInteger = '整';
  //整型完以后的单位
  var cnIntLast = '元';
  //最大处理的数字
  var maxNum = 999999999999999.9999;
  //金额整数部分
  var integerNum;
  //金额小数部分
  var decimalNum;
  //输出的中文金额字符串
  var chineseStr = '';
  //分离金额后用的数组，预定义
  var parts;
  if (money == '') { return ''; }
  money = parseFloat(money);
  if (money >= maxNum) {
    //超出最大处理数字
    return '';
  }
  if (money == 0) {
    chineseStr = cnNums[0] + cnIntLast + cnInteger;
    return chineseStr;
  }
  //转换为字符串
  money = money.toString();
  if (money.indexOf('.') == -1) {
    integerNum = money;
    decimalNum = '';
  } else {
    parts = money.split('.');
    integerNum = parts[0];
    decimalNum = parts[1].substr(0, 4);
  }
  //获取整型部分转换
  if (parseInt(integerNum, 10) > 0) {
    var zeroCount = 0;
    var IntLen = integerNum.length;
    for (var i = 0; i < IntLen; i++) {
      var n = integerNum.substr(i, 1);
      var p = IntLen - i - 1;
      var q = p / 4;
      var m = p % 4;
      if (n == '0') {
        zeroCount++;
      } else {
        if (zeroCount > 0) {
          chineseStr += cnNums[0];
        }
        //归零
        zeroCount = 0;
        chineseStr += cnNums[parseInt(n)] + cnIntRadice[m];
      }
      if (m == 0 && zeroCount < 4) {
        chineseStr += cnIntUnits[q];
      }
    }
    chineseStr += cnIntLast;
  }
  //小数部分
  if (decimalNum != '') {
    var decLen = decimalNum.length;
    for (var i = 0; i < decLen; i++) {
      var n = decimalNum.substr(i, 1);
      if (n != '0') {
        chineseStr += cnNums[Number(n)] + cnDecUnits[i];
      }
    }
  }
  if (chineseStr == '') {
    chineseStr += cnNums[0] + cnIntLast + cnInteger;
  } else if (decimalNum == '') {
    chineseStr += cnInteger;
  }
  return chineseStr;
}

// 过去时间转换
export function formatPast(param, format = 'YYYY-MM-DD HH:mm:ss') {
  // 传入格式处理、存储转换值
  let t, s
  // 获取js 时间戳
  let time = new Date().getTime()
  // 是否是对象
  typeof param === 'string' || 'object' ? (t = new Date(param).getTime()) : (t = param)
  // 当前时间戳 - 传入时间戳
  time = Number.parseInt(`${time - t}`)
  if (time < 10000) {
    // 10秒内
    return '刚刚'
  } else if (time < 60000 && time >= 10000) {
    // 超过10秒少于1分钟内
    s = Math.floor(time / 1000)
    return `${s}秒前`
  } else if (time < 3600000 && time >= 60000) {
    // 超过1分钟少于1小时
    s = Math.floor(time / 60000)
    return `${s}分钟前`
  } else if (time < 86400000 && time >= 3600000) {
    // 超过1小时少于24小时
    s = Math.floor(time / 3600000)
    return `${s}小时前`
  } else if (time < 10*24*60*60*1000 && time >= 86400000) {
    // 超过1天少于10天内
    s = Math.floor(time / 86400000)
    return `${s}天前`
  } else {
    // 超过10天
    const date = typeof param === 'string' || 'object' ? new Date(param) : param
    // return dayjs(date).format(format);
    return param;
  }
}

/**
 * 获取浏览器类型
 */
function getBrowserType () {
  var userAgent = navigator.userAgent; //取得浏览器的userAgent字符串
    var isOpera = userAgent.indexOf("Opera") > -1; //判断是否Opera浏览器
    var isIE = userAgent.indexOf("compatible") > -1 && userAgent.indexOf("MSIE") > -1 && !isOpera; //判断是否IE浏览器
    var isIE11 = !!window.ActiveXObject || "ActiveXObject" in window; // 判断是否IE11
    var isFF = userAgent.indexOf("Firefox") > -1; //判断是否Firefox浏览器
    var isSafari = userAgent.indexOf("Safari") > -1; //判断是否Safari浏览器
    var isChrome = userAgent.indexOf('Chrome') > -1; // 判断你是否Chrome乱临其
    if (isIE || isIE11) {
        var IE5 = IE55 = IE6 = IE7 = IE8 = false;
        var reIE = new RegExp("MSIE (\\d+\\.\\d+);");
        reIE.test(userAgent);
        var fIEVersion = parseFloat(RegExp["$1"]);
        IE55 = fIEVersion == 5.5;
        IE6 = fIEVersion == 6.0;
        IE7 = fIEVersion == 7.0;
        IE8 = fIEVersion == 8.0;
        if (IE55) {
            return "IE55";
        }
        if (IE6) {
            return "IE6";
        }
        if (IE7) {
            return "IE7";
        }
        if (IE8) {
            return "IE8";
        } else {
          return "IE";
        }
    }//isIE end
  if (isFF) {
    return "Firefox";
  }
  if (isOpera) {
    return "Opera";
  }
  if (isSafari) {
    return "Safari";
  }
  if (isChrome) {
    return 'Chrome';
  }
}

// 解析地址参数
function parseURL(url) {
  var a =  document.createElement('a');
  a.href = url;
  return {
    source: url,
    protocol: a.protocol.replace(':',''),
    host: a.hostname,
    port: a.port,
    query: a.search,
    params: (function(){
      let search = decodeURIComponent(a.search);
      var ret = {},
        seg = search.replace(/^\?/,'').split('&'),
        len = seg.length, i = 0, s;
      for (;i<len;i++) {
        if (!seg[i]) { continue; }
        s = seg[i].split('=');
        ret[s[0]] = s[1];
      }
      return ret;
    })(),
    file: (a.pathname.match(/\/([^\/?#]+)$/i) || [,''])[1],
    hash: a.hash.replace('#',''),
    path: a.pathname.replace(/^([^\/])/,'/$1'),
    relative: (a.href.match(/tps?:\/\/[^\/]+(.+)/) || [,''])[1],
    segments: a.pathname.replace(/^\//,'').split('/')
  };
}

// 组装路由参数
function joinUrl(path, query) {
  let arr = [];
  for(let key in query) {
    arr.push(key+'='+query[key]);
  }
  if(arr.length) {
    path+='?'+arr.join('&')
  }
  return path;
}

// base64转文件
function base64ToFile(base64, fileName) {
  var arr = base64.split(','),
    mime = arr[0].match(/:(.*?);/)[1],
    bstr = atob(arr[1]),
    n = bstr.length,
    u8arr = new Uint8Array(n);
  while (n--) {
    u8arr[n] = bstr.charCodeAt(n);
  }
  var theBlob = new Blob([u8arr], { type: mime });
  theBlob.lastModifiedDate = new Date();  // 文件最后的修改日期
  theBlob.name = fileName;                // 文件名
  return new File([theBlob], fileName, {type: theBlob.type, lastModified: Date.now()});
}

// 深度拷贝
export function deepCopy(target, source) {
    for (let key in source) {
        if (source.hasOwnProperty(key)) {
            if (source[key] instanceof Object && target[key] instanceof Object) {
                target[key] = deepCopy(target[key], source[key]);
            } else {
                target[key] = source[key];
            }
        }
    }
    return target;
}

export default {
  cookie,
  storage,
  switchTime,
  makeUpNum,
  calcTimeToNowText,
  copy,
  isEmpty,
  toFixed,
  getLabelByValue,
  getClanByValue,
  toNumber,
  getBirthdayByIdcard,
  getSexByIdcard,
  waitTimeout,
  getId,
  convertCurrency,
  formatPast,
  getBrowserType,
  parseURL,
  joinUrl,
  base64ToFile,
  deepCopy,
};

